using System;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("CraftingManager")]
	public class CraftingManager : MonoBehaviour
	{
		public Transform m_floatingCardBone => method_3<Transform>("m_floatingCardBone");

		public Transform m_faceDownCardBone => method_3<Transform>("m_faceDownCardBone");

		public Transform m_cardInfoPaneBone => method_3<Transform>("m_cardInfoPaneBone");

		public Transform m_cardCounterBone => method_3<Transform>("m_cardCounterBone");

		public Transform m_showCraftingUIBone => method_3<Transform>("m_showCraftingUIBone");

		public Transform m_hideCraftingUIBone => method_3<Transform>("m_hideCraftingUIBone");

		public BoxCollider m_offClickCatcher => method_3<BoxCollider>("m_offClickCatcher");

		public CraftCardCountTab m_cardCountTab => method_3<CraftCardCountTab>("m_cardCountTab");

		public Vector3 m_cardCountTabShowScale => method_2<Vector3>("m_cardCountTabShowScale");

		public Vector3 m_cardCountTabHideScale => method_2<Vector3>("m_cardCountTabHideScale");

		public PegUIElement m_switchPremiumButton => method_3<PegUIElement>("m_switchPremiumButton");

		public float m_timeForCardToFlipUp => method_2<float>("m_timeForCardToFlipUp");

		public float m_timeForBackCardToMoveUp => method_2<float>("m_timeForBackCardToMoveUp");

		public float m_delayBeforeBackCardMovesUp => method_2<float>("m_delayBeforeBackCardMovesUp");

		public iTween.EaseType m_easeTypeForCardFlip => method_2<iTween.EaseType>("m_easeTypeForCardFlip");

		public iTween.EaseType m_easeTypeForCardMoveUp => method_2<iTween.EaseType>("m_easeTypeForCardMoveUp");

		public CraftingUI m_craftingUI => method_3<CraftingUI>("m_craftingUI");

		public Actor m_currentBigActor => method_3<Actor>("m_currentBigActor");

		public bool m_isCurrentActorAGhost => method_2<bool>("m_isCurrentActorAGhost");

		public Actor m_upsideDownActor => method_3<Actor>("m_upsideDownActor");

		public Actor m_currentHeroPowerActor => method_3<Actor>("m_currentHeroPowerActor");

		public Actor m_ghostWeaponActor => method_3<Actor>("m_ghostWeaponActor");

		public Actor m_ghostMinionActor => method_3<Actor>("m_ghostMinionActor");

		public Actor m_ghostSpellActor => method_3<Actor>("m_ghostSpellActor");

		public Actor m_ghostHeroActor => method_3<Actor>("m_ghostHeroActor");

		public Actor m_ghostHeroPowerActor => method_3<Actor>("m_ghostHeroPowerActor");

		public Actor m_templateWeaponActor => method_3<Actor>("m_templateWeaponActor");

		public Actor m_templateSpellActor => method_3<Actor>("m_templateSpellActor");

		public Actor m_templateMinionActor => method_3<Actor>("m_templateMinionActor");

		public Actor m_templateHeroSkinActor => method_3<Actor>("m_templateHeroSkinActor");

		public Actor m_templateHeroActor => method_3<Actor>("m_templateHeroActor");

		public Actor m_templateHeroPowerActor => method_3<Actor>("m_templateHeroPowerActor");

		public Actor m_hiddenActor => method_3<Actor>("m_hiddenActor");

		public CardInfoPane m_cardInfoPane => method_3<CardInfoPane>("m_cardInfoPane");

		public Actor m_templateGoldenWeaponActor => method_3<Actor>("m_templateGoldenWeaponActor");

		public Actor m_templateGoldenSpellActor => method_3<Actor>("m_templateGoldenSpellActor");

		public Actor m_templateGoldenMinionActor => method_3<Actor>("m_templateGoldenMinionActor");

		public Actor m_templateGoldenHeroActor => method_3<Actor>("m_templateGoldenHeroActor");

		public Actor m_templateGoldenHeroPowerActor => method_3<Actor>("m_templateGoldenHeroPowerActor");

		public Actor m_ghostGoldenWeaponActor => method_3<Actor>("m_ghostGoldenWeaponActor");

		public Actor m_ghostGoldenSpellActor => method_3<Actor>("m_ghostGoldenSpellActor");

		public Actor m_ghostGoldenMinionActor => method_3<Actor>("m_ghostGoldenMinionActor");

		public Actor m_ghostGoldenHeroActor => method_3<Actor>("m_ghostGoldenHeroActor");

		public Actor m_ghostGoldenHeroPowerActor => method_3<Actor>("m_ghostGoldenHeroPowerActor");

		public bool m_cancellingCraftMode => method_2<bool>("m_cancellingCraftMode");

		public long m_unCommitedArcaneDustAdjustments => method_2<long>("m_unCommitedArcaneDustAdjustments");

		public PendingTransaction m_pendingClientTransaction => method_3<PendingTransaction>("m_pendingClientTransaction");

		public PendingTransaction m_pendingServerTransaction => method_3<PendingTransaction>("m_pendingServerTransaction");

		public Vector3 m_craftSourcePosition => method_2<Vector3>("m_craftSourcePosition");

		public Vector3 m_craftSourceScale => method_2<Vector3>("m_craftSourceScale");

		public CollectionCardActors m_cardActors => method_3<CollectionCardActors>("m_cardActors");

		public Actor m_collectionCardActor => method_3<Actor>("m_collectionCardActor");

		public static float HERO_POWER_TWEEN_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "CraftingManager", "HERO_POWER_TWEEN_TIME");

		public bool IsInCraftingMode => method_11<bool>("get_IsInCraftingMode", Array.Empty<object>());

		public CraftingManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public CraftingManager(IntPtr address)
			: this(address, "CraftingManager")
		{
		}

		public static CraftingManager Get()
		{
			return MonoClass.smethod_15<CraftingManager>(TritonHs.MainAssemblyPath, "", "CraftingManager", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void SwitchPremiumView(UIEvent e)
		{
			method_8("SwitchPremiumView", e);
		}

		public NetCache.CardValue GetCardValue(string cardID, TAG_PREMIUM premium)
		{
			return method_14<NetCache.CardValue>("GetCardValue", new object[2] { cardID, premium });
		}

		public bool IsCardShowing()
		{
			return method_11<bool>("IsCardShowing", Array.Empty<object>());
		}

		public Actor GetShownActor()
		{
			return method_14<Actor>("GetShownActor", Array.Empty<object>());
		}

		public void OnMassDisenchant(int amount)
		{
			method_8("OnMassDisenchant", amount);
		}

		public long GetUnCommitedArcaneDustChanges()
		{
			return method_11<long>("GetUnCommitedArcaneDustChanges", Array.Empty<object>());
		}

		public void AdjustUnCommitedArcaneDustChanges(int amount)
		{
			method_8("AdjustUnCommitedArcaneDustChanges", amount);
		}

		public void ResetUnCommitedArcaneDustChanges()
		{
			method_8("ResetUnCommitedArcaneDustChanges");
		}

		public int GetNumClientTransactions()
		{
			return method_11<int>("GetNumClientTransactions", Array.Empty<object>());
		}

		public void NotifyOfTransaction(int amt)
		{
			method_8("NotifyOfTransaction", amt);
		}

		public bool IsCancelling()
		{
			return method_11<bool>("IsCancelling", Array.Empty<object>());
		}

		public Actor CreateActorCopy(Actor actor, TAG_PREMIUM premium)
		{
			return method_14<Actor>("CreateActorCopy", new object[2] { actor, premium });
		}

		public void SetupActor(Actor collectionCardActor, TAG_PREMIUM premium)
		{
			method_8("SetupActor", collectionCardActor, premium);
		}

		public bool CancelCraftMode()
		{
			return method_11<bool>("CancelCraftMode", Array.Empty<object>());
		}

		public void CreateButtonPressed()
		{
			method_8("CreateButtonPressed");
		}

		public void DisenchantButtonPressed()
		{
			method_8("DisenchantButtonPressed");
		}

		public void UpdateBankText()
		{
			method_8("UpdateBankText");
		}

		public void TellServerAboutWhatUserDid()
		{
			method_8("TellServerAboutWhatUserDid");
		}

		public void OnCardGenericError(Network.CardSaleResult sale)
		{
			method_8("OnCardGenericError", sale);
		}

		public void OnCardPermissionError(Network.CardSaleResult sale)
		{
			method_8("OnCardPermissionError", sale);
		}

		public void OnCardDisenchantSoulboundError(Network.CardSaleResult sale)
		{
			method_8("OnCardDisenchantSoulboundError", sale);
		}

		public void OnCardCountError(Network.CardSaleResult sale)
		{
			method_8("OnCardCountError", sale);
		}

		public void OnCardCraftingEventNotActiveError(Network.CardSaleResult sale)
		{
			method_8("OnCardCraftingEventNotActiveError", sale);
		}

		public void OnCardUnknownError(Network.CardSaleResult sale)
		{
			method_8("OnCardUnknownError", sale);
		}

		public void OnCardDisenchanted(Network.CardSaleResult sale)
		{
			method_8("OnCardDisenchanted", sale);
		}

		public void OnCardCreated(Network.CardSaleResult sale)
		{
			method_8("OnCardCreated", sale);
		}

		public void LoadGhostActorIfNecessary()
		{
			method_8("LoadGhostActorIfNecessary");
		}

		public Actor LoadNewActorAndConstructIt()
		{
			return method_14<Actor>("LoadNewActorAndConstructIt", Array.Empty<object>());
		}

		public void ForceNonGhostFlagOn()
		{
			method_8("ForceNonGhostFlagOn");
		}

		public void FinishCreateAnims()
		{
			method_8("FinishCreateAnims");
		}

		public void FlipCurrentActor()
		{
			method_8("FlipCurrentActor");
		}

		public void FinishFlipCurrentActorEarly()
		{
			method_8("FinishFlipCurrentActorEarly");
		}

		public void FlipUpsideDownCard(Actor oldActor)
		{
			method_8("FlipUpsideDownCard", oldActor);
		}

		public void OnCardFlipComplete()
		{
			method_8("OnCardFlipComplete");
		}

		public PendingTransaction GetPendingClientTransaction()
		{
			return method_14<PendingTransaction>("GetPendingClientTransaction", Array.Empty<object>());
		}

		public PendingTransaction GetPendingServerTransaction()
		{
			return method_14<PendingTransaction>("GetPendingServerTransaction", Array.Empty<object>());
		}

		public void ShowCraftingUI(UIEvent e)
		{
			method_8("ShowCraftingUI", e);
		}

		public Actor GetCurrentActor()
		{
			return method_14<Actor>("GetCurrentActor", Array.Empty<object>());
		}

		public void MoveCardToBigSpot(Actor collectionCardActor, TAG_PREMIUM premium)
		{
			method_8("MoveCardToBigSpot", collectionCardActor, premium);
		}

		public void ShowHeroPowerBigCard(TAG_PREMIUM premium)
		{
			method_8("ShowHeroPowerBigCard", premium);
		}

		public void HideHeroPowerBigCard()
		{
			method_8("HideHeroPowerBigCard");
		}

		public void FinishBigCardMove()
		{
			method_8("FinishBigCardMove");
		}

		public void UpdateCardInfoPane()
		{
			method_8("UpdateCardInfoPane");
		}

		public void FinishActorMoveTowardsScreen()
		{
			method_8("FinishActorMoveTowardsScreen");
		}

		public void FinishActorMoveAway()
		{
			method_8("FinishActorMoveAway");
		}

		public void FadeEffectsIn()
		{
			method_8("FadeEffectsIn");
		}

		public void FadeEffectsOut()
		{
			method_8("FadeEffectsOut");
		}

		public void OnVignetteFinished()
		{
			method_8("OnVignetteFinished");
		}

		public Actor GetAndPositionNewUpsideDownActor(Actor oldActor, bool fromPage)
		{
			return method_14<Actor>("GetAndPositionNewUpsideDownActor", new object[2] { oldActor, fromPage });
		}

		public Actor GetAndPositionNewActor(Actor oldActor, int numCopies)
		{
			return method_14<Actor>("GetAndPositionNewActor", new object[2] { oldActor, numCopies });
		}

		public Actor GetGhostActor(Actor actor)
		{
			return method_14<Actor>("GetGhostActor", new object[1] { actor });
		}

		public Actor GetNonGhostActor(Actor actor)
		{
			return method_14<Actor>("GetNonGhostActor", new object[1] { actor });
		}

		public Actor GetTemplateActor(Actor actor)
		{
			return method_14<Actor>("GetTemplateActor", new object[1] { actor });
		}

		public Actor SetUpNonGhostActor(Actor templateActor, Actor actor)
		{
			return method_14<Actor>("SetUpNonGhostActor", new object[2] { templateActor, actor });
		}

		public Actor SetUpGhostActor(Actor templateActor, Actor actor)
		{
			return method_14<Actor>("SetUpGhostActor", new object[2] { templateActor, actor });
		}

		public void SetBigActorLayer(bool inCraftingMode)
		{
			method_8("SetBigActorLayer", inCraftingMode);
		}

		public CollectionCardVisual GetCurrentCardVisual()
		{
			return method_14<CollectionCardVisual>("GetCurrentCardVisual", Array.Empty<object>());
		}

		public int GetNumOwnedIncludePending(TAG_PREMIUM premium)
		{
			return method_10<int>("GetNumOwnedIncludePending", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { premium });
		}

		public int GetNumOwnedIncludePending()
		{
			return method_10<int>("GetNumOwnedIncludePending", new Class276.Enum20[0], Array.Empty<object>());
		}
	}
}
